package com.xianyuwangyou.taizhangdengji

import android.content.Context
import android.os.Build
import android.os.Environment
import android.util.Log
import com.google.gson.Gson
import com.google.gson.reflect.TypeToken
import java.io.File
import java.io.InputStreamReader
import java.io.OutputStreamWriter

class AccountDataManager private constructor() {
    private var accountRecords: MutableList<AccountRecord> = mutableListOf()
    private lateinit var appContext: Context
    private val TAG = "AccountDataManager"

    companion object {
        @Volatile
        private var INSTANCE: AccountDataManager? = null

        fun getInstance(): AccountDataManager {
            return INSTANCE ?: synchronized(this) {
                INSTANCE ?: AccountDataManager().also { INSTANCE = it }
            }
        }
    }

    // 添加一个公共方法来设置accountRecords
    public fun setAccountRecords(records: List<AccountRecord>) {
        accountRecords = records.toMutableList()
    }

    fun loadAccountData(context: Context) {
        try {
            appContext = context.applicationContext
            // 首先尝试从应用外部存储加载数据
            val externalFile = getExternalDataFile(context, "account_data.json")
            if (externalFile.exists()) {
                val inputStream = externalFile.inputStream()
                val reader = InputStreamReader(inputStream)
                val gson = Gson()
                val listType = object : TypeToken<List<AccountRecord>>() {}.type
                accountRecords = gson.fromJson(reader, listType) ?: mutableListOf()
                reader.close()
                Log.d(TAG, "从应用外部存储加载了 ${accountRecords.size} 条记录")
            } else {
                // 如果应用外部存储中没有数据文件，则尝试从内部存储加载数据（备份恢复的数据）
                try {
                    val inputStream = context.openFileInput("account_data.json")
                    val reader = InputStreamReader(inputStream)
                    val gson = Gson()
                    val listType = object : TypeToken<List<AccountRecord>>() {}.type
                    accountRecords = gson.fromJson(reader, listType) ?: mutableListOf()
                    reader.close()
                    Log.d(TAG, "从内部存储加载了 ${accountRecords.size} 条记录")
                    
                    // 将数据迁移到应用外部存储
                    saveAccountDataToFile(context)
                    
                    // 删除内部存储的旧文件
                    try {
                        context.deleteFile("account_data.json")
                    } catch (e: Exception) {
                        Log.w(TAG, "删除内部存储旧文件失败", e)
                    }
                } catch (internalException: Exception) {
                    Log.e(TAG, "从内部存储加载数据失败，尝试从assets加载", internalException)
                    // 如果内部存储中没有数据文件，则从assets加载
                    try {
                        val inputStream = context.assets.open("account_data.json")
                        val reader = InputStreamReader(inputStream)
                        val gson = Gson()
                        val listType = object : TypeToken<List<AccountRecord>>() {}.type
                        accountRecords = gson.fromJson(reader, listType) ?: mutableListOf()
                        reader.close()
                        Log.d(TAG, "从assets加载了 ${accountRecords.size} 条记录")
                        
                        // 将数据保存到应用外部存储
                        saveAccountDataToFile(context)
                    } catch (assetsException: Exception) {
                        Log.e(TAG, "从assets加载数据失败", assetsException)
                        accountRecords = mutableListOf()
                    }
                }
            }
        } catch (e: Exception) {
            Log.e(TAG, "从应用外部存储加载数据失败", e)
            accountRecords = mutableListOf()
        }
    }

    fun getAccountRecords(): List<AccountRecord> {
        return accountRecords
    }

    fun getRecordsByDate(date: String): List<AccountRecord> {
        return accountRecords.filter { it.date == date }
    }

    fun getAllDates(): List<String> {
        return accountRecords.map { it.date }.distinct().sortedDescending()
    }
    
    // 获取应用外部存储数据文件路径（真正的持久化存储）
    private fun getExternalDataFile(context: Context, fileName: String): File {
        // 使用现代方式获取外部存储目录，适配Android 10及以上版本
        val externalDir = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
            if (Environment.isExternalStorageLegacy()) {
                // 旧版存储方式，兼容低版本Android
                File(Environment.getExternalStorageDirectory(), "TaizhangDengji")
            } else {
                // 新版存储方式，使用应用特定的外部存储目录
                // Context.getExternalFilesDir(null)返回的目录在应用卸载时会被删除
                // 为了确保数据持久性，我们使用外部公共目录
                val externalPublicDir = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOCUMENTS)
                File(externalPublicDir, "TaizhangDengji")
            }
        } else {
            // Android 9及以下版本
            File(Environment.getExternalStorageDirectory(), "TaizhangDengji")
        }
        
        if (!externalDir.exists()) {
            externalDir.mkdirs()
        }
        return File(externalDir, fileName)
    }
    
    // 获取应用特定外部存储数据文件路径（会随应用卸载而删除）
    private fun getAppSpecificExternalDataFile(context: Context, fileName: String): File {
        // 使用应用特定的外部存储目录
        val externalDir = File(context.getExternalFilesDir(null), "data")
        if (!externalDir.exists()) {
            externalDir.mkdirs()
        }
        return File(externalDir, fileName)
    }
    
    // 在实际应用中，我们需要使用应用外部存储来保存数据
    fun saveAccountDataToFile(context: Context) {
        try {
            val gson = Gson()
            val json = gson.toJson(accountRecords)
            
            // 保存到外部存储（用户数据持久化）
            val externalFile = getExternalDataFile(context, "account_data.json")
            val writer = OutputStreamWriter(externalFile.outputStream())
            writer.write(json)
            writer.close()
            Log.d(TAG, "成功保存 ${accountRecords.size} 条记录到应用外部存储: ${externalFile.absolutePath}")
            
            // 同时保存到内部存储（用于备份功能）
            val internalWriter = OutputStreamWriter(context.openFileOutput("account_data.json", Context.MODE_PRIVATE))
            internalWriter.write(json)
            internalWriter.close()
            Log.d(TAG, "成功保存 ${accountRecords.size} 条记录到内部存储，用于备份")
        } catch (e: Exception) {
            Log.e(TAG, "保存数据到应用外部存储失败", e)
        }
    }
    
    fun loadAccountDataFromFile(context: Context) {
        loadAccountData(context)
    }
    
    fun addAccountRecordAndSave(record: AccountRecord, context: Context) {
        // 添加新记录到列表
        accountRecords.add(record)
        Log.d(TAG, "添加新记录: $record")
        
        // 保存到文件
        saveAccountDataToFile(context)
    }

    fun updateAccountRecordAndSave(updatedRecord: AccountRecord, context: Context) {
        // 查找并更新记录
        val index = accountRecords.indexOfFirst { it.id == updatedRecord.id }
        if (index != -1) {
            accountRecords[index] = updatedRecord
            Log.d(TAG, "更新记录: $updatedRecord")
            
            // 保存到文件
            saveAccountDataToFile(context)
        }
    }

    fun deleteAccountRecordAndSave(recordId: Int, context: Context) {
        // 查找并删除记录
        val index = accountRecords.indexOfFirst { it.id == recordId }
        if (index != -1) {
            val removedRecord = accountRecords.removeAt(index)
            Log.d(TAG, "删除记录: $removedRecord")
            
            // 保存到文件
            saveAccountDataToFile(context)
        }
    }
}